package Note_for_class;

import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 姚东名
 * Date: 2024-05-05
 * Time: 10:34
 */
public class Test0505 {
    public static void main(String[] args) {
        //想要输入 就要导入包：
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//与C语言中的scanf是一样的

        int sum = 0;
        for (int i = 1; i <= n; i++) {
            int ret = 1;
            for (int j = 1; j <= i; j++) {
                ret *= j;
            }
            sum += ret;
        }
        System.out.println(sum);
    }
    public static void main14(String[] args) {
        //do while 循环
        int a = 1;
        do {
            System.out.print(a+" ");
            a++;
        }while(a <= 10);
        System.out.println();//换行

        //for循环：for(表达式1; 表达式2; 表达式3)
        //循环顺序：表达式1 -> 表达式2 -> 循环体 -> 表达式3 -> 表达式2(看条件是否成立，成立就) -> 循环体……
        for (int i = 0; i < 10; i++) {
            System.out.print(i+" ");
        }
    }
    public static void main13(String[] args) {
        //break与continue
        //1.break的功能是让循环提前结束。直接跳出整个循环
        int i = 1;
        while(i <= 7){
            if(i == 3){
                break;
            }
            System.out.print(i+" ");//1 2
            i++;
        }

        //2.continue的功能是跳出本次循环，进入下一次循环(与break有着区别)
//        while(i <= 7){
//            if(i == 3){
//                //一般Continue前面都带有i++
//                continue;
//            }
//            System.out.print(i+" ");//死循环了
//            i++;
//        }//直接跳出while循环 进行下一次循环 还是 i==3 还是走if语句 变成了死循环

        //求出 1-100之间 所有既能被3  也能被5 整除的数字  要使用break 或者continue 做
        int j = 1;
        while(j <= 100){
            if(j % 15 !=0){
                j++;
                continue;
            }
            System.out.print(j+" ");//1 2 15 30 45 60 75 90
            j++;
        }
    }
    public static void main12(String[] args) {
        //循环相关的：while > for > do while(括号里面都需要布尔表达式)
        //1.while：
        //打印1~10的值：
//        int a = 1;
//          while(a <= 10){
//            System.out.print(a+" ");
//            a++;
//        }
//        while(true){//条件为真 程序会一直跑下去
//            System.out.println(a);
//            a++;

        //2.计算1~100之间的和
        int n = 1;
        int sum = 0;
        while (n <= 100){
            sum += n;
            n++;
        }
        System.out.println("sum = "+sum);//sum = 5050
        //3.计算100的阶乘
        int num = 1;
        int ret = 1;
        while(num <= 10){
            ret *= num;
            num++;
        }
        System.out.println("ret = " + ret);//3628800

        //4.计算1！ + 2！ + 3！ + 4！ + 5！
        int j = 1;
        int sum1 = 0;
        while(j <= 5){
            int i = 1;
            int ret1 = 1;
            while(i <= j){
                ret1 *= i;//求一个数的阶层
                i++;
            }
            sum1 += ret1;//求一个就加起来
            j++;
        }
        System.out.println(sum1);//总数
    }
    public static void main11(String[] args) {
        //switch语句：
        /*int a = 10;
        switch (a > 10){
            //switch()里面有：不能有float、double、long、boolean，其他都可以
        }*/
        //int a = 1;
        /*switch(a){//整型也是可以的
            case 1:
                System.out.println("haha");
                break;
            case 2:
                System.out.println("hehe");
                break;
            case 3:
                System.out.println("heihei");
                break;
            case 4:
                System.out.println("liuliu");
                break;
            default:
                System.out.println("enen");
                break;
        }*/
        /*String flag = "hello";//字符串也可以的
        switch(flag){
            case "haha":
                System.out.println("haha");
                break;
            case "hehe":
                System.out.println("hehe");
                break;
            case "heihei":
                System.out.println("heihei");
                break;
            case "liuliu":
                System.out.println("liuliu");
                break;
            default:
                System.out.println("hello");
                break;
        }*/
        /*boolean flag = true;
        switch(flag){//java: 不兼容的类型: boolean无法转换为int
            case true:
                System.out.println(1);
                break;
            case false:
                System.out.println(2);
                break;
            default:
                System.out.println("haha");
                break;
        }*/

        /*long flag = 1;
        switch(flag){//java: 不兼容的类型: 从long转换到int可能会有损失
            case 1:
                System.out.println(1);
                break;
            case 2:
                System.out.println(2);
                break;
            case 3:
                System.out.println(3);
            default:
                System.out.println("haha");
                break;
        }*/
        //结论：
        //switch()里面：不能有float(浮点型)、double(双精度浮点型)、long(长整型)、boolean(布尔类型)
        //      可以有： 整型相关的、枚举类型、字符串
        //     switch类型的参数不可以是复杂的表达式(语句)

        int x = 1;
        int y = 1;
        switch(x) {
            case 1:
                switch(y) {
                    case 1:
                        System.out.println("hehe");//YES
                        break;
                }
                break;
            case 2:
                System.out.println("haha");
                break;
        }
    }
    public static void main10(String[] args) {
        //悬垂else问题：
        //if / else 语句中可以不加 大括号 . 但是也可以写语句(只能写一条语句). 此时 else 是和最接近的 if 匹配.
        int x = 10;
        int y = 10;
        if(x == 10) {
            if (y == 10) {
                System.out.println("aaa");//YSE
            }
            else {
                System.out.println("bbb");
            }
        }
    }
    public static void main9(String[] args) {
        //顺序结构：
        System.out.println("aaa");
        System.out.println("bbb");
        System.out.println("ccc");
        System.out.println("bbb");
        //分支结构：
        //if语句
//        //1.判断一个数是奇数还是偶数
//        int num = 0;
//        if (num%2 == 0) {
//            System.out.println("num是偶数");
//        }else{
//            System.out.println("num是奇数");
//        }

        //2.判断一个数是正数还是负数
        /*int num1 = 10;
        if(num1 > 0){
            System.out.println("正数");
        }else if(num1 < 0) {
            System.out.println("负数");
        }else{
            System.out.println("0");
        }*/
        //3.判断一个年份是否为闰年
        int year = 2000;
        if(year%100 == 0){
            //世纪闰年
            if(year%400 == 0){
                System.out.println("是闰年");
            }else{
                System.out.println("不是闰年");
            }
        }else{
            //普通闰年
            if(year%4 == 0){
                System.out.println("是闰年");
            }else{
                System.out.println("不是闰年");
            }
        }

    }
    public static void main8(String[] args) {
        //三目操作符/条件运算符
        //布尔表达式1 ？ 布尔表达式2 ：布尔表达式3
        //如果表达式1为真 则返回表达式2的结果 否则 返回表达式3的结果
        boolean flag = (true == true) ? (true == false ? false : true ): false;
        System.out.println(flag);//true

        // 求a和b的平均值
        int a = 10;
        int b = 20;
        int c = a + ((b - a) >> 1);//10 + (10>>1) == 15
        System.out.println(c);//15
        int d = a + (b - a) >> 1;//10 + 10 >> 1 == 10(加号运算符优先级高于右移运算符)
        System.out.println(d);
    }
    public static void main7(String[] args) {
        //移位运算符(了解)
        //1.左移 << :最右侧位不要了，最右侧补零
       /* int a = 0x10;//0001 0000 >> 1 == 0000 1000
        System.out.printf("%x\n", a >> 1);//8 %x是以16进制打印的
        //10(16) -> 16(10)：过程：1*16^1 + 0*16^0 = 16
        System.out.printf("%x\n",a);
        //2.右移 >> :最左侧位不要了，最左侧补符号位
        System.out.printf("%x\n", a << 1);//20
        //0001 0000 << 1 == 0010 0000(2) -> 20(16)
        //3.无符号右移 >>>：无符号右移 最右侧不要了，最左侧补零*/
        int b = -1;
        System.out.printf("%x\n", b>>>1);
        //10000000000000000000000000000001
        //11111111111111111111111111111110
        //0111 1111 1111 1111 1111 1111 1111 1111(补码) ->无符号：直接输出：
        //7    f    f    f    f    f    f    f ->0x7fffffff

        //左移小技巧：n * 2 ^ x == 11*2^1 == 22
        //右移小技巧：n / 2 ^ x == 22/2^1 == 11
    }
    public static void main6(String[] args) {
        //位运算符：主要有四个 &、|、^、~
        //1.按位与 &：如果两个二进制都为1，则结果为1 反之结果为0
        int a = 10;//01010
        int b = 20;//10100
        System.out.println(a & b);//00000 ->0

        //2.按位或 |：如果两个二进制都为0 则结果为0 存在1 都是1
        System.out.println(a | b);//11110 ->30

        //3.按位异或 ^:只有相反时 才为1 相同时 为0
        System.out.println(a ^ b);//11110 ->30

        //4.按位取反 ~：1变0  0变1
        System.out.println(~a);//10101 ->-11
        //1111111111111111111111111111111110101
        //1000000000000000000000000000000001010
        //1000000000000000000000000000000001011 ->-11
        //System.out.printf("%x\n",~a);
        //总结一个规律：
        //n ^ n == 0
        //n ^ 0 == 1
        //与逻辑与、逻辑或、逻辑非的区别是：没有短路处理
        System.out.println(10 > 20 & 10 / 0 == 0);//会报错
        System.out.println(10 < 20 | 10 / 0 == 0);//会报错

    }
    public static void main5(String[] args) {
        //逻辑运算符：&&、||、！ 运算结果都是 boolean类型
        //1.逻辑与：&& 语法规则：
        //boolean表达式 && boolean表达式 两者为真时，结果才为真
        int a = 10;
        int b = 20;
        System.out.println(a == 10 && b == 20);//true
        System.out.println(a == 10 && b != 20);//false
        System.out.println(a > 10 && b == 20);//false
        System.out.println(a < 20 && b == 20 );//true

        //2.逻辑或，|| 语法规则：
        //boolean表达式 && boolean表达式 只要一边为真 结果为真
        System.out.println(a == 10 || b == 20);//true
        System.out.println(a == 10 || b > 100);//true
        System.out.println(a != 10 || b == 20);//true
        System.out.println(a > 100 || b != 20);//false

        //3.逻辑非：！ 语法规则：
        //！表达式 （不需要boolean表达式）真变假 假边真
        System.out.println(!true);//false
        System.out.println(!false);//true

        //4.短路求值：&&、||都遵循短路求值规则
        System.out.println(10 > 20 && 10 / 0 == 0);//false
        System.out.println(10 < 20 || 10 / 0 == 0);//true
        //都知道10/0 是会报错的 但是上面的代码能够运行 证明10/0 并没有真正被求值
        //- 对于&&来说，左侧表达式false则表达式地结果一定为false，无需计算右侧的表达式
        //- 对于||来说，左侧表达式true则表达式地结果一定为true，无需计算右侧的表达式
    }
    public static void main4(String[] args) {
        //关系运算符：==、！=、<、>、<=、>=
        //其计算结果是 true 或 false
        int a = 10;
        int b = 20;
        System.out.println(a == b);//false
        System.out.println(a > b);//false
        System.out.println(a != b);//true
        System.out.println(a < b);//true
        System.out.println(a >= b);//false
        System.out.println(a <= b);//true

        //注意：当需要多次判断是 不能连着写
        //System.out.println(5 < a < 15);//error
    }
    public static void main3(String[] args) {
        //自增/自减运算符++ --
        //前置++ --
        int a = 10;
        int b = ++a;
        System.out.println(a);//11
        System.out.println(b);//11
        //后置++ --
        int c = 10;
        int d = c++;
        System.out.println(c);//11
        System.out.println(d);//10
    }
    //增量运算符 +=、-=、*=、%=
    public static void main2(String[] args) {
        int a = 1;
        a +=2;
        System.out.println(a);//3
        int b = 2;
        b -= 2;
        System.out.println(b);//0
        int c = 3;
        c *= 3;
        System.out.println(c);//9
        int d = 20;
        d %= 2;
        System.out.println(d);//0
        //注意：只有变量才能使用该运算符 常量不能使用
    }
    //算术运算符
    public static void main1(String[] args) {
//        int a = 10;
//        int b = 20;
//
//        System.out.println(a + b);//30
//        System.out.println(a - b);//-10
//        System.out.println(a * b);//200
//        System.out.println(a / b);//0
//        System.out.println(a % b);//10
        //二元运算符，使用时必须要有左右两个操作符
        //1.向下取整：
//        int a = 3;
//        int b = 2;
//        System.out.println(a / b);//1 小数点之后部分舍弃
//        //保留小数点后的部分：
//        double d = (a*1.0)/b;
//        System.out.println(d);//1.5

        //2.做除法时和取模，右操作数不能为0
        int a = 10;
        int b = 0;
        System.out.println(a / b);/// by zero 报错

        //3.%不仅可以对整取模，也可以对double类型取模 但是意义不大
        System.out.println(1.5 % 2.0);//1.5
    }
}
